.TH std::move_only_function::move_only_function 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::move_only_function::move_only_function \- std::move_only_function::move_only_function

.SH Synopsis
   move_only_function() noexcept;                                     \fB(1)\fP (since C++23)
   move_only_function( std::nullptr_t ) noexcept;                     \fB(2)\fP (since C++23)
   move_only_function( move_only_function&& other ) noexcept;         \fB(3)\fP (since C++23)
   move_only_function( const move_only_function& ) = delete;          \fB(4)\fP (since C++23)
   template< class F >                                                \fB(5)\fP (since C++23)
   move_only_function( F&& f );
   template< class T, class... CArgs >
   explicit move_only_function( std::in_place_type_t<T>, CArgs&&...   \fB(6)\fP (since C++23)
   args );
   template< class T, class U, class... CArgs >

   explicit move_only_function( std::in_place_type_t<T>,              \fB(7)\fP (since C++23)

                                std::initializer_list<U> il,
   CArgs&&... args );

   Creates a new std::move_only_function.

   1,2) Default constructor and the constructor taking nullptr construct an empty
   std::move_only_function.
   3) Move constructor constructs a std::move_only_function whose target is that of
   other. other is in a valid but unspecified state after move construction.
   4) Copy constructor is deleted. std::move_only_function does not satisfy
   CopyConstructible.
   5) Let VT be std::decay_t<F>. If f is a null function pointer, a null pointer to
   member value, or an empty std::move_only_function (may be any specialization), then
   constructs an empty std::move_only_function. Otherwise, constructs a
   std::move_only_function whose target is of type VT and direct-non-list-initialized
   with std::forward<F>(f).
     * This overload participates in overload resolution only if VT is neither same as
       move_only_function nor a specialization of std::in_place_type_t, and
       /*is-callable-from*/<VT> (see below) is true.
     * The program is ill-formed if std::is_constructible_v<VT, F> is not true.
   6) Let VT be std::decay_t<T>. Constructs a std::move_only_function whose target is
   of type VT and direct-non-list-initialized with std::forward<CArgs>(args)....
     * This overload participates in overload resolution only if both
       std::is_constructible_v<VT, CArgs...> and /*is-callable-from*/<VT> (see below)
       are true.
     * The program is ill-formed if VT is not the same type as T.
   7) Let VT be std::decay_t<T>. Constructs a std::move_only_function whose target is
   of type VT and direct-non-list-initialized with il, std::forward<CArgs>(args)....
     * This overload participates in overload resolution only if both
       std::is_constructible_v<VT, std::initializer_list<U>&, CArgs...> and
       /*is-callable-from*/<VT> (see below) are true.
     * The program is ill-formed if VT is not the same type as T.

   For constructors (5-7), the behavior is undefined if VT does not satisfy the
   Destructible requirements, or std::is_move_constructible_v<VT> is true but VT does
   not satisfy the MoveConstructible requirements.

   The constant /*is-callable-from*/<VT> is dependent on cv, ref, and noex in the
   template parameter of std::move_only_function as below:

    cv ref noexcept(noex)                  /*is-callable-from*/<VT>
                            std::is_invocable_r_v<R, VT, Args...> &&
       noexcept(false)
                            std::is_invocable_r_v<R, VT&, Args...>
                            std::is_nothrow_invocable_r_v<R, VT, Args...> &&
        noexcept(true)
                            std::is_nothrow_invocable_r_v<R, VT&, Args...>
                            std::is_invocable_r_v<R, const VT, Args...> &&
    const noexcept(false)
                            std::is_invocable_r_v<R, const VT&, Args...>
                            std::is_nothrow_invocable_r_v<R, const VT, Args...> &&
     const noexcept(true)
                            std::is_nothrow_invocable_r_v<R, const VT&, Args...>
      & noexcept(false)     std::is_invocable_r_v<R, VT&, Args...>
       & noexcept(true)     std::is_nothrow_invocable_r_v<R, VT&, Args...>
   const & noexcept(false)  std::is_invocable_r_v<R, const VT&, Args...>
    const & noexcept(true)  std::is_nothrow_invocable_r_v<R, const VT&, Args...>
      && noexcept(false)    std::is_invocable_r_v<R, VT, Args...>
      && noexcept(true)     std::is_nothrow_invocable_r_v<R, VT, Args...>
   const && noexcept(false) std::is_invocable_r_v<R, const VT, Args...>
   const && noexcept(true)  std::is_nothrow_invocable_r_v<R, const VT, Args...>

.SH Parameters

   other - another std::move_only_function to move from
   f     - a function or a Callable object to wrap
   args  - arguments to construct the target object
   il    - std::initializer_list to construct the target object

.SH Exceptions

   5-7) May throw std::bad_alloc on allocation failure or propagate the exception
   thrown by the initialization of the target. No exception is thrown if VT is a
   function pointer type or a specialization of std::reference_wrapper.

.SH Example

    This section is incomplete
    Reason: no example

.SH See also

   constructor   constructs a new std::function instance
                 \fI(public member function of std::function<R(Args...)>)\fP

.SH Category:
     * Todo no example
